/**
 * 本地缓存管理工具类
 * 支持哈希结构存储，设置过期时间
 */

const CACHE_PREFIX = 'hire_cache_';
const DEFAULT_EXPIRE_TIME = 30 * 60 * 1000; // 默认30分钟过期

/**
 * 缓存数据结构
 * {
 *   data: any,           // 实际数据
 *   expire: number,      // 过期时间戳
 *   createTime: number   // 创建时间戳
 * }
 */

class CacheManager {
  /**
   * 设置缓存
   * @param {string} key - 缓存键
   * @param {any} data - 缓存数据
   * @param {number} expireTime - 过期时间（毫秒），默认30分钟
   */
  set(key, data, expireTime = DEFAULT_EXPIRE_TIME) {
    const cacheKey = CACHE_PREFIX + key;
    const now = Date.now();
    
    const cacheData = {
      data: data,
      expire: now + expireTime,
      createTime: now
    };
    
    try {
      uni.setStorageSync(cacheKey, JSON.stringify(cacheData));
    } catch (error) {
      console.error(`设置缓存失败: ${key}`, error);
    }
  }

  /**
   * 获取缓存
   * @param {string} key - 缓存键
   * @returns {any|null} - 缓存数据，过期或不存在返回null
   */
  get(key) {
    const cacheKey = CACHE_PREFIX + key;
    
    try {
      const cacheString = uni.getStorageSync(cacheKey);
      if (!cacheString) {
        return null;
      }
      
      const cacheData = JSON.parse(cacheString);
      const now = Date.now();
      
      // 检查是否过期
      if (now > cacheData.expire) {
        this.remove(key); // 删除过期缓存
        return null;
      }
      
      return cacheData.data;
    } catch (error) {
      console.error(`获取缓存失败: ${key}`, error);
      this.remove(key); // 删除异常缓存
      return null;
    }
  }

  /**
   * 检查缓存是否存在且未过期
   * @param {string} key - 缓存键
   * @returns {boolean} - 缓存是否有效
   */
  has(key) {
    return this.get(key) !== null;
  }

  /**
   * 删除缓存
   * @param {string} key - 缓存键
   */
  remove(key) {
    const cacheKey = CACHE_PREFIX + key;
    
    try {
      uni.removeStorageSync(cacheKey);
    } catch (error) {
      console.error(`删除缓存失败: ${key}`, error);
    }
  }

  /**
   * 清空所有相关缓存
   */
  clear() {
    try {
      const storageInfo = uni.getStorageInfoSync();
      const keys = storageInfo.keys || [];
      
      keys.forEach(key => {
        if (key.startsWith(CACHE_PREFIX)) {
          uni.removeStorageSync(key);
        }
      });
    } catch (error) {
      console.error('清空缓存失败', error);
    }
  }

  /**
   * 获取缓存信息
   * @param {string} key - 缓存键
   * @returns {object|null} - 缓存信息
   */
  getInfo(key) {
    const cacheKey = CACHE_PREFIX + key;
    
    try {
      const cacheString = uni.getStorageSync(cacheKey);
      if (!cacheString) {
        return null;
      }
      
      const cacheData = JSON.parse(cacheString);
      const now = Date.now();
      
      return {
        key: key,
        createTime: new Date(cacheData.createTime).toLocaleString(),
        expireTime: new Date(cacheData.expire).toLocaleString(),
        isExpired: now > cacheData.expire,
        remainingTime: Math.max(0, cacheData.expire - now)
      };
    } catch (error) {
      console.error(`获取缓存信息失败: ${key}`, error);
      return null;
    }
  }
}

// 创建单例实例
const cacheManager = new CacheManager();

/**
 * 行业类别缓存管理器
 * 专门用于管理行业类别数据的缓存
 */
export class JobTypeCacheManager {
  constructor() {
    this.cache = cacheManager;
    this.CACHE_EXPIRE_TIME = 2 * 60 * 60 * 1000; // 2小时过期
  }

  /**
   * 获取一级分类缓存键
   * @returns {string}
   */
  getTopLevelKey() {
    return 'job_type_top_list';
  }

  /**
   * 获取子级分类缓存键
   * @param {string} fatherId - 父级ID
   * @returns {string}
   */
  getChildrenKey(fatherId) {
    return `job_type_children_${fatherId}`;
  }

  /**
   * 设置一级分类缓存
   * @param {array} data - 一级分类数据
   */
  setTopLevelData(data) {
    this.cache.set(this.getTopLevelKey(), data, this.CACHE_EXPIRE_TIME);
  }

  /**
   * 获取一级分类缓存
   * @returns {array|null}
   */
  getTopLevelData() {
    return this.cache.get(this.getTopLevelKey());
  }

  /**
   * 设置子级分类缓存
   * @param {string} fatherId - 父级ID
   * @param {array} data - 子级分类数据
   */
  setChildrenData(fatherId, data) {
    this.cache.set(this.getChildrenKey(fatherId), data, this.CACHE_EXPIRE_TIME);
  }

  /**
   * 获取子级分类缓存
   * @param {string} fatherId - 父级ID
   * @returns {array|null}
   */
  getChildrenData(fatherId) {
    return this.cache.get(this.getChildrenKey(fatherId));
  }

  /**
   * 检查子级分类缓存是否存在
   * @param {string} fatherId - 父级ID
   * @returns {boolean}
   */
  hasChildrenData(fatherId) {
    return this.cache.has(this.getChildrenKey(fatherId));
  }

  /**
   * 清空所有行业类别缓存
   */
  clearAll() {
    // 清空一级分类缓存
    this.cache.remove(this.getTopLevelKey());
    
    // 清空所有子级分类缓存（通过遍历存储信息）
    try {
      const storageInfo = uni.getStorageInfoSync();
      const keys = storageInfo.keys || [];
      
      keys.forEach(key => {
        if (key.startsWith(CACHE_PREFIX + 'job_type_children_')) {
          uni.removeStorageSync(key);
        }
      });
    } catch (error) {
      console.error('清空行业类别缓存失败', error);
    }
  }

  /**
   * 获取缓存统计信息
   * @returns {object}
   */
  getCacheStats() {
    const stats = {
      topLevel: this.cache.getInfo(this.getTopLevelKey()),
      children: [],
      totalSize: 0
    };

    try {
      const storageInfo = uni.getStorageInfoSync();
      const keys = storageInfo.keys || [];
      
      keys.forEach(key => {
        if (key.startsWith(CACHE_PREFIX + 'job_type_children_')) {
          const fatherId = key.replace(CACHE_PREFIX + 'job_type_children_', '');
          const info = this.cache.getInfo(`job_type_children_${fatherId}`);
          if (info) {
            stats.children.push(info);
          }
        }
      });
      
      stats.totalSize = keys.filter(key => key.startsWith(CACHE_PREFIX + 'job_type')).length;
    } catch (error) {
      console.error('获取缓存统计失败', error);
    }

    return stats;
  }
}

/**
 * 公司规模缓存管理器
 * 专门用于管理公司规模数据的缓存
 */
export class CompanySizeCacheManager {
  constructor() {
    this.cache = cacheManager;
    this.CACHE_EXPIRE_TIME = 24 * 60 * 60 * 1000; // 24小时过期
  }

  /**
   * 获取公司规模缓存键
   * @returns {string}
   */
  getKey() {
    return 'company_size_list';
  }

  /**
   * 设置公司规模缓存
   * @param {array} data - 公司规模数据
   */
  setData(data) {
    this.cache.set(this.getKey(), data, this.CACHE_EXPIRE_TIME);
  }

  /**
   * 获取公司规模缓存
   * @returns {array|null}
   */
  getData() {
    return this.cache.get(this.getKey());
  }

  /**
   * 根据dataKey获取公司规模值
   * @param {string} dataKey - dataKey
   * @returns {string}
   */
  getValueByDataKey(dataKey) {
    const data = this.getData();
    if (!data || !Array.isArray(data)) return dataKey;
    
    const item = data.find(item => item.dataKey === dataKey);
    return item ? item.value : dataKey;
  }

  /**
   * 清空公司规模缓存
   */
  clear() {
    this.cache.remove(this.getKey());
  }
}

// 默认导出缓存管理器实例
export default cacheManager;

// 导出行业类别缓存管理器实例
export const jobTypeCacheManager = new JobTypeCacheManager();

// 导出公司规模缓存管理器实例
export const companySizeCacheManager = new CompanySizeCacheManager();

/**
 * 字典数据缓存管理器
 * 专门用于管理字典数据的缓存，支持批量存储和获取
 */
export class DictionaryCacheManager {
  constructor() {
    this.cache = cacheManager;
    this.CACHE_EXPIRE_TIME = 2 * 60 * 60 * 1000; // 2小时过期
  }

  /**
   * 获取字典数据缓存键
   * @returns {string}
   */
  getKey() {
    return 'dictionary_data_map';
  }

  /**
   * 设置字典数据缓存
   * @param {object} dictionaryMap - 字典数据映射 { typeKey: [...] }
   */
  setData(dictionaryMap) {
    this.cache.set(this.getKey(), dictionaryMap, this.CACHE_EXPIRE_TIME);
  }

  /**
   * 获取所有字典数据缓存
   * @returns {object|null}
   */
  getData() {
    
    return this.cache.get(this.getKey());
  }

  /**
   * 根据typeKey获取字典数据
   * @param {string} typeKey - 字典类型键
   * @returns {array|null}
   */
  getDataByType(typeKey) {
    const data = this.getData();
    
    if (!data || typeof data !== 'object') return null;
    return data[typeKey] || null;
  }

  /**
   * 根据typeKey和dataKey获取字典值
   * @param {string} typeKey - 字典类型键
   * @param {string} dataKey - 字典数据键
   * @returns {string|null}
   */
  getValueByKeys(typeKey, dataKey) {
    const typeData = this.getDataByType(typeKey);
    if (!typeData || !Array.isArray(typeData)) return null;
    
    const item = typeData.find(item => item.dataKey === dataKey);
    
    return item ? item.value : null;
  }

  /**
   * 根据typeKey和dataKey获取字典项（包含icon等完整信息）
   * @param {string} typeKey - 字典类型键
   * @param {string} dataKey - 字典数据键
   * @returns {object|null}
   */
  getItemByKeys(typeKey, dataKey) {
    const typeData = this.getDataByType(typeKey);
    console.log("typeKey",typeKey,typeData);
    
    if (!typeData || !Array.isArray(typeData)) return null;
    
    return typeData.find(item => item.dataKey === dataKey) || null;
  }

  /**
   * 检查指定类型的字典数据是否存在
   * @param {string} typeKey - 字典类型键
   * @returns {boolean}
   */
  hasTypeData(typeKey) {
    const typeData = this.getDataByType(typeKey);
    return typeData !== null && Array.isArray(typeData);
  }

  /**
   * 检查是否有任何字典数据缓存
   * @returns {boolean}
   */
  hasData() {
    return this.cache.has(this.getKey());
  }

  /**
   * 清空字典数据缓存
   */
  clear() {
    this.cache.remove(this.getKey());
  }

  /**
   * 格式化多个字段的值（用逗号分隔的字段）
   * @param {string} typeKey - 字典类型键
   * @param {string} fieldValue - 字段值（逗号分隔）
   * @returns {array} - 格式化后的数组，包含value和icon
   */
  formatMultipleValues(typeKey, fieldValue) {
    if (!fieldValue || typeof fieldValue !== 'string') return [];
    
    const dataKeys = fieldValue.split(' ').map(key => key.trim()).filter(key => key);
    console.log("dataKeys",dataKeys);
    
    const result = [];
    
    dataKeys.forEach(dataKey => {
      const item = this.getItemByKeys(typeKey, dataKey);
      
      if (item) {
        result.push({
          dataKey: item.dataKey,
          value: item.value,
          icon: item.icon,
          remark: item.remark
        });
      }
    });
    
    return result;
  }
}

// 导出字典数据缓存管理器实例
export const dictionaryCacheManager = new DictionaryCacheManager();